{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Collaborative filtering on Google Analytics data\n",
    "\n",
    "This notebook demonstrates how to implement a WALS matrix refactorization approach to do collaborative filtering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "PROJECT = \"cloud-training-demos\" # REPLACE WITH YOUR PROJECT ID\n",
    "BUCKET = \"cloud-training-demos-ml\" # REPLACE WITH YOUR BUCKET NAME\n",
    "REGION = \"us-central1\" # REPLACE WITH YOUR BUCKET REGION e.g. us-central1\n",
    "\n",
    "# Do not change these\n",
    "os.environ[\"PROJECT\"] = PROJECT\n",
    "os.environ[\"BUCKET\"] = BUCKET\n",
    "os.environ[\"REGION\"] = REGION\n",
    "os.environ[\"TFVERSION\"] = \"1.13\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Updated property [core/project].\n",
      "Updated property [compute/region].\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "gcloud config set project $PROJECT\n",
    "gcloud config set compute/region $REGION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.13.1\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Create raw dataset\n",
    "<p>\n",
    "For collaborative filtering, we don't need to know anything about either the users or the content. Essentially, all we need to know is userId, itemId, and rating that the particular user gave the particular item.\n",
    "<p>\n",
    "In this case, we are working with newspaper articles. The company doesn't ask their users to rate the articles. However, we can use the time-spent on the page as a proxy for rating.\n",
    "<p>\n",
    "Normally, we would also add a time filter to this (\"latest 7 days\"), but our dataset is itself limited to a few days."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>visitorId</th>\n",
       "      <th>contentId</th>\n",
       "      <th>session_duration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1000148716229112932-150</td>\n",
       "      <td>299913879</td>\n",
       "      <td>24501</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1000148716229112932-150</td>\n",
       "      <td>299912101</td>\n",
       "      <td>48539</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1000163602560555666-481</td>\n",
       "      <td>299918278</td>\n",
       "      <td>51196</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000163602560555666-478</td>\n",
       "      <td>298888038</td>\n",
       "      <td>30383</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1000163602560555666-481</td>\n",
       "      <td>299912085</td>\n",
       "      <td>20331</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 visitorId  contentId  session_duration\n",
       "0  1000148716229112932-150  299913879             24501\n",
       "1  1000148716229112932-150  299912101             48539\n",
       "2  1000163602560555666-481  299918278             51196\n",
       "3  1000163602560555666-478  298888038             30383\n",
       "4  1000163602560555666-481  299912085             20331"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from google.cloud import bigquery\n",
    "bq = bigquery.Client(project = PROJECT)\n",
    "\n",
    "sql = \"\"\"\n",
    "WITH CTE_visitor_page_content AS (\n",
    "    SELECT\n",
    "        # Schema: https://support.google.com/analytics/answer/3437719?hl=en\n",
    "        # For a completely unique visit-session ID, we combine combination of fullVisitorId and visitNumber:\n",
    "        CONCAT(fullVisitorID,'-',CAST(visitNumber AS STRING)) AS visitorId,\n",
    "        (SELECT MAX(IF(index=10, value, NULL)) FROM UNNEST(hits.customDimensions)) AS latestContentId,  \n",
    "        (LEAD(hits.time, 1) OVER (PARTITION BY fullVisitorId ORDER BY hits.time ASC) - hits.time) AS session_duration \n",
    "    FROM\n",
    "        `cloud-training-demos.GA360_test.ga_sessions_sample`,   \n",
    "        UNNEST(hits) AS hits\n",
    "    WHERE \n",
    "        # only include hits on pages\n",
    "        hits.type = \"PAGE\"\n",
    "GROUP BY   \n",
    "        fullVisitorId,\n",
    "        visitNumber,\n",
    "        latestContentId,\n",
    "        hits.time )\n",
    "-- Aggregate web stats\n",
    "SELECT   \n",
    "    visitorId,\n",
    "    latestContentId as contentId,\n",
    "    SUM(session_duration) AS session_duration\n",
    "FROM\n",
    "    CTE_visitor_page_content\n",
    "WHERE\n",
    "    latestContentId IS NOT NULL \n",
    "GROUP BY\n",
    "    visitorId, \n",
    "    latestContentId\n",
    "HAVING \n",
    "    session_duration > 0\n",
    "\"\"\"\n",
    "\n",
    "df = bq.query(sql).to_dataframe()\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>session_duration</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>2.843080e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.247931e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>2.311622e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.607200e+04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>5.627900e+04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>1.271780e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>7.690598e+06</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       session_duration\n",
       "count      2.843080e+05\n",
       "mean       1.247931e+05\n",
       "std        2.311622e+05\n",
       "min        1.000000e+00\n",
       "25%        1.607200e+04\n",
       "50%        5.627900e+04\n",
       "75%        1.271780e+05\n",
       "max        7.690598e+06"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats = df.describe()\n",
    "stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f2ed4282f98>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df[[\"session_duration\"]].plot(kind=\"hist\", logy=True, bins=100, figsize=[8,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f2ecea47da0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The rating is the session_duration scaled to be in the range 0-1.  This will help with training.\n",
    "median = stats.loc[\"50%\", \"session_duration\"]\n",
    "df[\"rating\"] = 0.3 * df[\"session_duration\"] / median\n",
    "df.loc[df[\"rating\"] > 1, \"rating\"] = 1\n",
    "df[[\"rating\"]].plot(kind=\"hist\", logy=True, bins=100, figsize=[8,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "del df[\"session_duration\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "rm -rf data\n",
    "mkdir data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df.to_csv(path_or_buf = \"data/collab_raw.csv\", index = False, header = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000148716229112932-150,299913879,0.1306046660388422\n",
      "1000148716229112932-150,299912101,0.25874127116686507\n",
      "1000163602560555666-481,299918278,0.27290463583219315\n",
      "1000163602560555666-478,298888038,0.1619591677179765\n",
      "1000163602560555666-481,299912085,0.10837612608610672\n",
      "1000163602560555666-478,299772450,0.027628422679862825\n",
      "1000196974485173657-270,299925086,0.005362568631283427\n",
      "1000196974485173657-271,299950903,0.09858384121963787\n",
      "1000196974485173657-273,299965875,0.15314771051369072\n",
      "1000196974485173657-274,299972194,0.3221485811759271\n"
     ]
    }
   ],
   "source": [
    "!head data/collab_raw.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Create dataset for WALS\n",
    "<p>\n",
    "The raw dataset (above) won't work for WALS:\n",
    "<ol>\n",
    "<li> The userId and itemId have to be 0,1,2 ... so we need to create a mapping from visitorId (in the raw data) to userId and contentId (in the raw data) to itemId.\n",
    "<li> We will need to save the above mapping to a file because at prediction time, we'll need to know how to map the contentId in the table above to the itemId.\n",
    "<li> We'll need two files: a \"rows\" dataset where all the items for a particular user are listed; and a \"columns\" dataset where all the users for a particular item are listed.\n",
    "</ol>\n",
    "\n",
    "<p>\n",
    "\n",
    "### Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "def create_mapping(values, filename):\n",
    "    with open(filename, 'w') as ofp:\n",
    "        value_to_id = {value:idx for idx, value in enumerate(values.unique())}\n",
    "        for value, idx in value_to_id.items():\n",
    "            ofp.write(\"{},{}\\n\".format(value, idx))\n",
    "    return value_to_id\n",
    "\n",
    "df = pd.read_csv(filepath_or_buffer = \"data/collab_raw.csv\",\n",
    "                 header = None,\n",
    "                 names = [\"visitorId\", \"contentId\", \"rating\"],\n",
    "                dtype = {\"visitorId\": str, \"contentId\": str, \"rating\": np.float})\n",
    "df.to_csv(path_or_buf = \"data/collab_raw.csv\", index = False, header = False)\n",
    "user_mapping = create_mapping(df[\"visitorId\"], \"data/users.csv\")\n",
    "item_mapping = create_mapping(df[\"contentId\"], \"data/items.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==> data/collab_raw.csv <==\n",
      "1000148716229112932-150,299913879,0.1306046660388422\n",
      "1000148716229112932-150,299912101,0.2587412711668651\n",
      "1000163602560555666-481,299918278,0.27290463583219315\n",
      "\n",
      "==> data/items.csv <==\n",
      "270101894,5598\n",
      "123146162,5133\n",
      "297753966,1386\n",
      "\n",
      "==> data/users.csv <==\n",
      "5920254686919747111-226,65388\n",
      "2877197600805658919-1495,13239\n",
      "2969314934247982067-1,85239\n"
     ]
    }
   ],
   "source": [
    "!head -3 data/*.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df[\"userId\"] = df[\"visitorId\"].map(user_mapping.get)\n",
    "df[\"itemId\"] = df[\"contentId\"].map(item_mapping.get)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>itemId</th>\n",
       "      <th>rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.130605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0.258741</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0.272905</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>0.161959</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>0.108376</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  itemId    rating\n",
       "0       0       0  0.130605\n",
       "1       0       1  0.258741\n",
       "2       1       2  0.272905\n",
       "3       2       3  0.161959\n",
       "4       1       4  0.108376"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mapped_df = df[[\"userId\", \"itemId\", \"rating\"]]\n",
    "mapped_df.to_csv(path_or_buf = \"data/collab_mapped.csv\", index = False, header = False)\n",
    "mapped_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Creating rows and columns datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>itemId</th>\n",
       "      <th>rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.130605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0.258741</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0.272905</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>0.161959</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>0.108376</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  itemId    rating\n",
       "0       0       0  0.130605\n",
       "1       0       1  0.258741\n",
       "2       1       2  0.272905\n",
       "3       2       3  0.161959\n",
       "4       1       4  0.108376"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "mapped_df = pd.read_csv(filepath_or_buffer = \"data/collab_mapped.csv\", header = None, names = [\"userId\", \"itemId\", \"rating\"])\n",
    "mapped_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5667 items, 120954 users, 284308 interactions\n"
     ]
    }
   ],
   "source": [
    "NITEMS = np.max(mapped_df[\"itemId\"]) + 1\n",
    "NUSERS = np.max(mapped_df[\"userId\"]) + 1\n",
    "mapped_df[\"rating\"] = np.round(mapped_df[\"rating\"].values, 2)\n",
    "print(\"{} items, {} users, {} interactions\".format( NITEMS, NUSERS, len(mapped_df) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "grouped_by_items = mapped_df.groupby(\"itemId\")\n",
    "iter = 0\n",
    "for item, grouped in grouped_by_items:\n",
    "    print(item, grouped[\"userId\"].values, grouped[\"rating\"].values)\n",
    "    iter = iter + 1\n",
    "    if iter > 5:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "grouped_by_items = mapped_df.groupby(\"itemId\")\n",
    "with tf.python_io.TFRecordWriter(\"data/users_for_item\") as ofp:\n",
    "    for item, grouped in grouped_by_items:\n",
    "        example = tf.train.Example(features = tf.train.Features(feature = {\n",
    "            \"key\": tf.train.Feature(int64_list = tf.train.Int64List(value = [item])),\n",
    "            \"indices\": tf.train.Feature(int64_list = tf.train.Int64List(value = grouped[\"userId\"].values)),\n",
    "            \"values\": tf.train.Feature(float_list = tf.train.FloatList(value = grouped[\"rating\"].values))\n",
    "        }))\n",
    "        ofp.write(example.SerializeToString())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "grouped_by_users = mapped_df.groupby(\"userId\")\n",
    "with tf.python_io.TFRecordWriter(\"data/items_for_user\") as ofp:\n",
    "    for user, grouped in grouped_by_users:\n",
    "        example = tf.train.Example(features = tf.train.Features(feature = {\n",
    "            \"key\": tf.train.Feature(int64_list = tf.train.Int64List(value = [user])),\n",
    "            \"indices\": tf.train.Feature(int64_list = tf.train.Int64List(value = grouped[\"itemId\"].values)),\n",
    "            \"values\": tf.train.Feature(float_list = tf.train.FloatList(value = grouped[\"rating\"].values))\n",
    "        }))\n",
    "        ofp.write(example.SerializeToString())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 31908\n",
      "-rw-r--r-- 1 jupyter jupyter 13152765 Jul 31 20:41 collab_raw.csv\n",
      "-rw-r--r-- 1 jupyter jupyter  2134511 Jul 31 20:41 users.csv\n",
      "-rw-r--r-- 1 jupyter jupyter    82947 Jul 31 20:41 items.csv\n",
      "-rw-r--r-- 1 jupyter jupyter  7812739 Jul 31 20:41 collab_mapped.csv\n",
      "-rw-r--r-- 1 jupyter jupyter  2252828 Jul 31 20:41 users_for_item\n",
      "-rw-r--r-- 1 jupyter jupyter  7217822 Jul 31 20:41 items_for_user\n"
     ]
    }
   ],
   "source": [
    "!ls -lrt data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "To summarize, we created the following data files from collab_raw.csv:\n",
    "<ol>\n",
    "<li> ```collab_mapped.csv``` is essentially the same data as in ```collab_raw.csv``` except that ```visitorId``` and ```contentId``` which are business-specific have been mapped to ```userId``` and ```itemId``` which are enumerated in 0,1,2,....  The mappings themselves are stored in ```items.csv``` and ```users.csv``` so that they can be used during inference.\n",
    "<li> ```users_for_item``` contains all the users/ratings for each item in TFExample format\n",
    "<li> ```items_for_user``` contains all the items/ratings for each user in TFExample format\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Train with WALS\n",
    "\n",
    "Once you have the dataset, do matrix factorization with WALS using the [WALSMatrixFactorization](https://www.tensorflow.org/versions/master/api_docs/python/tf/contrib/factorization/WALSMatrixFactorization) in the contrib directory.\n",
    "This is an estimator model, so it should be relatively familiar.\n",
    "<p>\n",
    "As usual, we write an input_fn to provide the data to the model, and then create the Estimator to do train_and_evaluate.\n",
    "Because it is in contrib and hasn't moved over to tf.estimator yet, we use tf.contrib.learn.Experiment to handle the training loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.lib.io import file_io\n",
    "from tensorflow.contrib.factorization import WALSMatrixFactorization\n",
    "  \n",
    "def read_dataset(mode, args):\n",
    "    def decode_example(protos, vocab_size):\n",
    "        features = {\n",
    "            \"key\": tf.FixedLenFeature(shape = [1], dtype = tf.int64),\n",
    "            \"indices\": tf.VarLenFeature(dtype = tf.int64),\n",
    "            \"values\": tf.VarLenFeature(dtype = tf.float32)}\n",
    "        parsed_features = tf.parse_single_example(serialized = protos, features = features)\n",
    "        values = tf.sparse_merge(sp_ids = parsed_features[\"indices\"], sp_values = parsed_features[\"values\"], vocab_size = vocab_size)\n",
    "        # Save key to remap after batching\n",
    "        # This is a temporary workaround to assign correct row numbers in each batch.\n",
    "        # You can ignore details of this part and remap_keys().\n",
    "        key = parsed_features[\"key\"]\n",
    "        decoded_sparse_tensor = tf.SparseTensor(indices = tf.concat(values = [values.indices, [key]], axis = 0), \n",
    "                                                values = tf.concat(values = [values.values, [0.0]], axis = 0), \n",
    "                                                dense_shape = values.dense_shape)\n",
    "        return decoded_sparse_tensor\n",
    "  \n",
    "  \n",
    "    def remap_keys(sparse_tensor):\n",
    "        # Current indices of our SparseTensor that we need to fix\n",
    "        bad_indices = sparse_tensor.indices # shape = (current_batch_size * (number_of_items/users[i] + 1), 2)\n",
    "        # Current values of our SparseTensor that we need to fix\n",
    "        bad_values = sparse_tensor.values # shape = (current_batch_size * (number_of_items/users[i] + 1),)\n",
    "\n",
    "        # Since batch is ordered, the last value for a batch index is the user\n",
    "        # Find where the batch index chages to extract the user rows\n",
    "        # 1 where user, else 0\n",
    "        user_mask = tf.concat(values = [bad_indices[1:,0] - bad_indices[:-1,0], tf.constant(value = [1], dtype = tf.int64)], axis = 0) # shape = (current_batch_size * (number_of_items/users[i] + 1), 2)\n",
    "\n",
    "        # Mask out the user rows from the values\n",
    "        good_values = tf.boolean_mask(tensor = bad_values, mask = tf.equal(x = user_mask, y = 0)) # shape = (current_batch_size * number_of_items/users[i],)\n",
    "        item_indices = tf.boolean_mask(tensor = bad_indices, mask = tf.equal(x = user_mask, y = 0)) # shape = (current_batch_size * number_of_items/users[i],)\n",
    "        user_indices = tf.boolean_mask(tensor = bad_indices, mask = tf.equal(x = user_mask, y = 1))[:, 1] # shape = (current_batch_size,)\n",
    "\n",
    "        good_user_indices = tf.gather(params = user_indices, indices = item_indices[:,0]) # shape = (current_batch_size * number_of_items/users[i],)\n",
    "\n",
    "        # User and item indices are rank 1, need to make rank 1 to concat\n",
    "        good_user_indices_expanded = tf.expand_dims(input = good_user_indices, axis = -1) # shape = (current_batch_size * number_of_items/users[i], 1)\n",
    "        good_item_indices_expanded = tf.expand_dims(input = item_indices[:, 1], axis = -1) # shape = (current_batch_size * number_of_items/users[i], 1)\n",
    "        good_indices = tf.concat(values = [good_user_indices_expanded, good_item_indices_expanded], axis = 1) # shape = (current_batch_size * number_of_items/users[i], 2)\n",
    "\n",
    "        remapped_sparse_tensor = tf.SparseTensor(indices = good_indices, values = good_values, dense_shape = sparse_tensor.dense_shape)\n",
    "        return remapped_sparse_tensor\n",
    "\n",
    "    \n",
    "    def parse_tfrecords(filename, vocab_size):\n",
    "        if mode == tf.estimator.ModeKeys.TRAIN:\n",
    "            num_epochs = None # indefinitely\n",
    "        else:\n",
    "            num_epochs = 1 # end-of-input after this\n",
    "\n",
    "        files = tf.gfile.Glob(filename = os.path.join(args[\"input_path\"], filename))\n",
    "\n",
    "        # Create dataset from file list\n",
    "        dataset = tf.data.TFRecordDataset(files)\n",
    "        dataset = dataset.map(map_func = lambda x: decode_example(x, vocab_size))\n",
    "        dataset = dataset.repeat(count = num_epochs)\n",
    "        dataset = dataset.batch(batch_size = args[\"batch_size\"])\n",
    "        dataset = dataset.map(map_func = lambda x: remap_keys(x))\n",
    "        return dataset.make_one_shot_iterator().get_next()\n",
    "  \n",
    "    def _input_fn():\n",
    "        features = {\n",
    "            WALSMatrixFactorization.INPUT_ROWS: parse_tfrecords(\"items_for_user\", args[\"nitems\"]),\n",
    "            WALSMatrixFactorization.INPUT_COLS: parse_tfrecords(\"users_for_item\", args[\"nusers\"]),\n",
    "            WALSMatrixFactorization.PROJECT_ROW: tf.constant(True)\n",
    "        }\n",
    "        return features, None\n",
    "\n",
    "    return _input_fn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This code is helpful in developing the input function. You don't need it in production."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SparseTensorValue(indices=array([[   0,    0],\n",
      "       [   0, 3522],\n",
      "       [   0, 3583],\n",
      "       [   1,    1],\n",
      "       [   1, 2359],\n",
      "       [   1, 3133],\n",
      "       [   1, 4864],\n",
      "       [   1, 4901],\n",
      "       [   1, 4906],\n",
      "       [   1, 5667],\n",
      "       [   2,    2],\n",
      "       [   3,    2],\n",
      "       [   3, 1467]]), values=array([0.23, 0.05, 0.18, 1.  , 0.11, 0.55, 0.3 , 0.72, 0.46, 0.3 , 0.25,\n",
      "       0.17, 0.13], dtype=float32), dense_shape=array([   4, 5721]))\n",
      "SparseTensorValue(indices=array([[   4,    3],\n",
      "       [   5,    4],\n",
      "       [   5, 5042],\n",
      "       [   5, 5525],\n",
      "       [   5, 5553],\n",
      "       [   6,    5],\n",
      "       [   7,    5]]), values=array([0.05, 0.95, 0.63, 1.  , 0.16, 1.  , 0.48], dtype=float32), dense_shape=array([   4, 5721]))\n"
     ]
    }
   ],
   "source": [
    "def try_out():\n",
    "    with tf.Session() as sess:\n",
    "        fn = read_dataset(\n",
    "            mode = tf.estimator.ModeKeys.EVAL, \n",
    "            args = {\"input_path\": \"data\", \"batch_size\": 4, \"nitems\": NITEMS, \"nusers\": NUSERS})\n",
    "        feats, _ = fn()\n",
    "        \n",
    "        print(feats[\"input_rows\"].eval())\n",
    "        print(feats[\"input_rows\"].eval())\n",
    "\n",
    "try_out()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def find_top_k(user, item_factors, k):\n",
    "    all_items = tf.matmul(a = tf.expand_dims(input = user, axis = 0), b = tf.transpose(a = item_factors))\n",
    "    topk = tf.nn.top_k(input = all_items, k = k)\n",
    "    return tf.cast(x = topk.indices, dtype = tf.int64)\n",
    "    \n",
    "def batch_predict(args):\n",
    "    import numpy as np\n",
    "    with tf.Session() as sess:\n",
    "        estimator = tf.contrib.factorization.WALSMatrixFactorization(\n",
    "            num_rows = args[\"nusers\"], \n",
    "            num_cols = args[\"nitems\"],\n",
    "            embedding_dimension = args[\"n_embeds\"],\n",
    "            model_dir = args[\"output_dir\"])\n",
    "        \n",
    "        # This is how you would get the row factors for out-of-vocab user data\n",
    "        # row_factors = list(estimator.get_projections(input_fn=read_dataset(tf.estimator.ModeKeys.EVAL, args)))\n",
    "        # user_factors = tf.convert_to_tensor(np.array(row_factors))\n",
    "\n",
    "        # But for in-vocab data, the row factors are already in the checkpoint\n",
    "        user_factors = tf.convert_to_tensor(value = estimator.get_row_factors()[0]) # (nusers, nembeds)\n",
    "        # In either case, we have to assume catalog doesn\"t change, so col_factors are read in\n",
    "        item_factors = tf.convert_to_tensor(value = estimator.get_col_factors()[0])# (nitems, nembeds)\n",
    "\n",
    "        # For each user, find the top K items\n",
    "        topk = tf.squeeze(input = tf.map_fn(fn = lambda user: find_top_k(user, item_factors, args[\"topk\"]), elems = user_factors, dtype = tf.int64))\n",
    "        with file_io.FileIO(os.path.join(args[\"output_dir\"], \"batch_pred.txt\"), mode = 'w') as f:\n",
    "            for best_items_for_user in topk.eval():\n",
    "                f.write(\",\".join(str(x) for x in best_items_for_user) + '\\n')\n",
    "\n",
    "def train_and_evaluate(args):\n",
    "    train_steps = int(0.5 + (1.0 * args[\"num_epochs\"] * args[\"nusers\"]) / args[\"batch_size\"])\n",
    "    steps_in_epoch = int(0.5 + args[\"nusers\"] / args[\"batch_size\"])\n",
    "    print(\"Will train for {} steps, evaluating once every {} steps\".format(train_steps, steps_in_epoch))\n",
    "    def experiment_fn(output_dir):\n",
    "        return tf.contrib.learn.Experiment(\n",
    "            tf.contrib.factorization.WALSMatrixFactorization(\n",
    "                num_rows = args[\"nusers\"], \n",
    "                num_cols = args[\"nitems\"],\n",
    "                embedding_dimension = args[\"n_embeds\"],\n",
    "                model_dir = args[\"output_dir\"]),\n",
    "            train_input_fn = read_dataset(tf.estimator.ModeKeys.TRAIN, args),\n",
    "            eval_input_fn = read_dataset(tf.estimator.ModeKeys.EVAL, args),\n",
    "            train_steps = train_steps,\n",
    "            eval_steps = 1,\n",
    "            min_eval_frequency = steps_in_epoch\n",
    "        )\n",
    "\n",
    "    from tensorflow.contrib.learn.python.learn import learn_runner\n",
    "    learn_runner.run(experiment_fn = experiment_fn, output_dir = args[\"output_dir\"])\n",
    "    \n",
    "    batch_predict(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Will train for 8 steps, evaluating once every 162 steps\n",
      "WARNING:tensorflow:From <ipython-input-25-4ad1e7c785ce>:49: run (from tensorflow.contrib.learn.python.learn.learn_runner) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.estimator.train_and_evaluate.\n",
      "WARNING:tensorflow:From /home/jupyter/.local/lib/python3.5/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.*\n",
      "WARNING:tensorflow:From /home/jupyter/.local/lib/python3.5/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead.\n",
      "INFO:tensorflow:Using default config.\n",
      "INFO:tensorflow:Using config: {'_tf_config': gpu_options {\n",
      "  per_process_gpu_memory_fraction: 1.0\n",
      "}\n",
      ", '_task_id': 0, '_is_chief': True, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7fb220516da0>, '_save_checkpoints_steps': None, '_task_type': None, '_tf_random_seed': None, '_save_summary_steps': 100, '_num_ps_replicas': 0, '_keep_checkpoint_max': 5, '_log_step_count_steps': 100, '_keep_checkpoint_every_n_hours': 10000, '_environment': 'local', '_eval_distribute': None, '_session_config': None, '_train_distribute': None, '_evaluation_master': '', '_num_worker_replicas': 0, '_device_fn': None, '_master': '', '_protocol': None, '_save_checkpoints_secs': 600, '_model_dir': 'wals_trained'}\n",
      "WARNING:tensorflow:From <ipython-input-25-4ad1e7c785ce>:45: Experiment.__init__ (from tensorflow.contrib.learn.python.learn.experiment) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please switch to tf.estimator.train_and_evaluate. You will also have to convert to a tf.estimator.Estimator.\n",
      "WARNING:tensorflow:From /home/jupyter/.local/lib/python3.5/site-packages/tensorflow/contrib/learn/python/learn/monitors.py:279: BaseMonitor.__init__ (from tensorflow.contrib.learn.python.learn.monitors) is deprecated and will be removed after 2016-12-05.\n",
      "Instructions for updating:\n",
      "Monitors are deprecated. Please use tf.train.SessionRunHook.\n",
      "WARNING:tensorflow:From /home/jupyter/.local/lib/python3.5/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /home/jupyter/.local/lib/python3.5/site-packages/tensorflow/contrib/factorization/python/ops/wals.py:315: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one.\n",
      "INFO:tensorflow:Create CheckpointSaverHook.\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Saving checkpoints for 0 into wals_trained/model.ckpt.\n",
      "INFO:tensorflow:SweepHook running init op.\n",
      "INFO:tensorflow:SweepHook running prep ops for the row sweep.\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:loss = 96509.96, step = 1\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:Next fit step starting.\n",
      "INFO:tensorflow:Saving checkpoints for 8 into wals_trained/model.ckpt.\n",
      "INFO:tensorflow:Loss for final step: 110142.75.\n",
      "WARNING:tensorflow:From /home/jupyter/.local/lib/python3.5/site-packages/tensorflow/python/ops/metrics_impl.py:363: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "INFO:tensorflow:Starting evaluation at 2019-07-31T20:43:12Z\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "WARNING:tensorflow:From /home/jupyter/.local/lib/python3.5/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from wals_trained/model.ckpt-8\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Evaluation [1/1]\n",
      "INFO:tensorflow:Finished evaluation at 2019-07-31-20:43:12\n",
      "INFO:tensorflow:Saving dict for global step 8: global_step = 8, loss = 96509.96\n",
      "INFO:tensorflow:Using default config.\n",
      "INFO:tensorflow:Using config: {'_tf_config': gpu_options {\n",
      "  per_process_gpu_memory_fraction: 1.0\n",
      "}\n",
      ", '_task_id': 0, '_is_chief': True, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7fb2207064e0>, '_save_checkpoints_steps': None, '_task_type': None, '_tf_random_seed': None, '_save_summary_steps': 100, '_num_ps_replicas': 0, '_keep_checkpoint_max': 5, '_log_step_count_steps': 100, '_keep_checkpoint_every_n_hours': 10000, '_environment': 'local', '_eval_distribute': None, '_session_config': None, '_train_distribute': None, '_evaluation_master': '', '_num_worker_replicas': 0, '_device_fn': None, '_master': '', '_protocol': None, '_save_checkpoints_secs': 600, '_model_dir': 'wals_trained'}\n"
     ]
    }
   ],
   "source": [
    "import shutil\n",
    "shutil.rmtree(path = \"wals_trained\", ignore_errors=True)\n",
    "train_and_evaluate({\n",
    "    \"output_dir\": \"wals_trained\",\n",
    "    \"input_path\": \"data/\",\n",
    "    \"num_epochs\": 0.05,\n",
    "    \"nitems\": NITEMS,\n",
    "    \"nusers\": NUSERS,\n",
    "\n",
    "    \"batch_size\": 512,\n",
    "    \"n_embeds\": 10,\n",
    "    \"topk\": 3\n",
    "  })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batch_pred.txt\t\t\t  model.ckpt-0.index\n",
      "checkpoint\t\t\t  model.ckpt-0.meta\n",
      "eval\t\t\t\t  model.ckpt-8.data-00000-of-00001\n",
      "events.out.tfevents.1564605788.r  model.ckpt-8.index\n",
      "graph.pbtxt\t\t\t  model.ckpt-8.meta\n",
      "model.ckpt-0.data-00000-of-00001\n"
     ]
    }
   ],
   "source": [
    "!ls wals_trained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "284,5609,36\n",
      "284,2754,42\n",
      "284,3168,534\n",
      "2621,5528,2694\n",
      "4409,5295,343\n",
      "5161,3267,3369\n",
      "5479,1335,55\n",
      "5479,1335,55\n",
      "4414,284,5572\n",
      "284,241,2359\n"
     ]
    }
   ],
   "source": [
    "!head wals_trained/batch_pred.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Run as a Python module\n",
    "\n",
    "Let's run it as Python module for just a few steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ[\"NITEMS\"] = str(NITEMS)\n",
    "os.environ[\"NUSERS\"] = str(NUSERS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "rm -rf wals.tar.gz wals_trained\n",
    "gcloud ai-platform local train \\\n",
    "    --module-name=walsmodel.task \\\n",
    "    --package-path=${PWD}/walsmodel \\\n",
    "    -- \\\n",
    "    --output_dir=${PWD}/wals_trained \\\n",
    "    --input_path=${PWD}/data \\\n",
    "    --num_epochs=0.01 --nitems=${NITEMS} --nusers=${NUSERS} \\\n",
    "    --job-dir=./tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Run on Cloud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "gcloud storage cp data/* gs://${BUCKET}/wals/data"   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "OUTDIR=gs://${BUCKET}/wals/model_trained\n",
    "JOBNAME=wals_$(date -u +%y%m%d_%H%M%S)\n",
    "echo $OUTDIR $REGION $JOBNAME\n",
    "gcloud storage rm --recursive --continue-on-error $OUTDIR\n",    "gcloud ai-platform jobs submit training $JOBNAME \\\n",
    "    --region=$REGION \\\n",
    "    --module-name=walsmodel.task \\\n",
    "    --package-path=${PWD}/walsmodel \\\n",
    "    --job-dir=$OUTDIR \\\n",
    "    --staging-bucket=gs://$BUCKET \\\n",
    "    --scale-tier=BASIC_GPU \\\n",
    "    --runtime-version=$TFVERSION \\\n",
    "    -- \\\n",
    "    --output_dir=$OUTDIR \\\n",
    "    --input_path=gs://${BUCKET}/wals/data \\\n",
    "    --num_epochs=10 --nitems=${NITEMS} --nusers=${NUSERS} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This took <b>10 minutes</b> for me."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get row and column factors\n",
    "\n",
    "Once you have a trained WALS model, you can get row and column factors (user and item embeddings) from the checkpoint file. We'll look at how to use these in the section on building a recommendation system using deep neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_factors(args):\n",
    "    with tf.Session() as sess:\n",
    "        estimator = tf.contrib.factorization.WALSMatrixFactorization(\n",
    "            num_rows = args[\"nusers\"], \n",
    "            num_cols = args[\"nitems\"],\n",
    "            embedding_dimension = args[\"n_embeds\"],\n",
    "            model_dir = args[\"output_dir\"])\n",
    "        \n",
    "        row_factors = estimator.get_row_factors()[0]\n",
    "        col_factors = estimator.get_col_factors()[0]\n",
    "    return row_factors, col_factors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Using default config.\n",
      "INFO:tensorflow:Using config: {'_environment': 'local', '_is_chief': True, '_keep_checkpoint_every_n_hours': 10000, '_num_worker_replicas': 0, '_session_config': None, '_task_type': None, '_eval_distribute': None, '_tf_config': gpu_options {\n",
      "  per_process_gpu_memory_fraction: 1.0\n",
      "}\n",
      ", '_master': '', '_log_step_count_steps': 100, '_model_dir': 'gs://qwiklabs-gcp-cbc8684b07fc2dbd-bucket/wals/model_trained', '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x7f4bd8302f28>, '_device_fn': None, '_keep_checkpoint_max': 5, '_task_id': 0, '_evaluation_master': '', '_save_checkpoints_steps': None, '_protocol': None, '_train_distribute': None, '_save_checkpoints_secs': 600, '_save_summary_steps': 100, '_tf_random_seed': None, '_num_ps_replicas': 0}\n",
      "[[ 3.3451824e-06 -1.1986867e-05  4.8447573e-06 -1.5209486e-05\n",
      "  -1.7004859e-07  1.1976428e-05  9.8887876e-06  7.2386983e-06\n",
      "  -7.0237149e-07 -7.9796819e-06]\n",
      " [-2.5300323e-03  1.4055537e-03 -9.8291773e-04 -4.2533795e-03\n",
      "  -1.4166030e-03 -1.9530674e-03  8.5932651e-04 -1.5276540e-03\n",
      "   2.1342330e-03  1.2041229e-03]\n",
      " [ 9.5228699e-21  5.5453966e-21  2.2947056e-21 -5.8859543e-21\n",
      "   7.7516509e-21 -2.7640896e-20  2.3587296e-20 -3.9876822e-21\n",
      "   1.7312470e-20  2.5409211e-20]]\n",
      "[[-1.2125404e-06 -8.6304914e-05  4.4657736e-05 -6.8423047e-05\n",
      "   5.8551927e-06  9.7241784e-05  6.6776753e-05  1.6673854e-05\n",
      "  -1.2708440e-05 -5.1148414e-05]\n",
      " [-1.1353870e-01  5.9097271e-02 -4.6105500e-02 -1.5460028e-01\n",
      "  -1.9166643e-02 -7.3236257e-02  3.5582058e-02 -5.6805085e-02\n",
      "   7.5831160e-02  7.5306065e-02]\n",
      " [ 7.1989548e-20  4.4574543e-20  6.5149121e-21 -4.6291777e-20\n",
      "   8.8196718e-20 -2.3245078e-19  1.9459292e-19  4.0191465e-20\n",
      "   1.6273659e-19  2.2836562e-19]]\n"
     ]
    }
   ],
   "source": [
    "args = {\n",
    "    \"output_dir\": \"gs://{}/wals/model_trained\".format(BUCKET),\n",
    "    \"nitems\": NITEMS,\n",
    "    \"nusers\": NUSERS,\n",
    "    \"n_embeds\": 10\n",
    "  }\n",
    "\n",
    "user_embeddings, item_embeddings = get_factors(args)\n",
    "print(user_embeddings[:3])\n",
    "print(item_embeddings[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can visualize the embedding vectors using dimensional reduction techniques such as PCA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<mpl_toolkits.mplot3d.art3d.Path3DCollection at 0x7f4b9406c438>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "pca = PCA(n_components = 3)\n",
    "pca.fit(user_embeddings)\n",
    "user_embeddings_pca = pca.transform(user_embeddings)\n",
    "\n",
    "fig = plt.figure(figsize = (8,8))\n",
    "ax = fig.add_subplot(111, projection = \"3d\")\n",
    "xs, ys, zs = user_embeddings_pca[::150].T\n",
    "ax.scatter(xs, ys, zs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<pre>\n",
    "# Copyright 2018 Google Inc. All Rights Reserved.\n",
    "#\n",
    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "#      http://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License.\n",
    "</pre>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
